import { ref, onMounted, nextTick, watch, computed } from 'vue'
import { PlusOutlined, UploadOutlined, SendOutlined, DeleteOutlined, PushpinOutlined, PushpinFilled, MessageOutlined, ExpandOutlined, CompressOutlined, CloseOutlined, PaperClipOutlined, PictureOutlined, FileOutlined, RocketOutlined, SearchOutlined, GlobalOutlined } from '@ant-design/icons-vue'
import { useAuthStore } from '../../stores/auth'
import { useChatStore } from '../../stores/chat'
import { chatApi } from '../../api/chat'
import { message, Modal } from 'ant-design-vue'
import { generateGuid } from '../../utils/guid'

/**
 * 聊天界面组合式函数模块
 * 负责聊天界面的业务逻辑，包括多会话窗口管理、消息发送、文件上传和UI交互
 * 提供响应式的会话状态管理和实时消息处理功能
 */

export const useChat = () => {
  const authStore = useAuthStore()
  const chatStore = useChatStore()

  const loading = ref(false)
  const messagesContainer = ref(null)

  // 多会话状态管理
  const activeSessions = ref(new Set()) // 活跃的会话窗口
  const maximizedSession = ref(null) // 最大化的会话窗口

  // 图片预览状态
  const imagePreviewVisible = ref(false)
  const previewImageUrl = ref('')

  // 监听会话状态变化，自动激活/停用会话
  watch(() => chatStore.activeSessions, (newActiveSessions) => {
    // 同步活跃会话状态
    activeSessions.value = new Set(newActiveSessions.keys())
  }, { deep: true })

  // 监听会话选择变化
  watch(() => chatStore.currentSessionId, (newSessionId, oldSessionId) => {
    if (newSessionId && newSessionId !== oldSessionId) {
      // 激活新选择的会话
      activateSession(newSessionId)
    }
  })

  // 生命周期
  onMounted(async () => {
    await loadSessions()
    
    // 监听会话消息变化，自动滚动到底部
    watch(() => chatStore.messages, () => {
      scrollToBottomNextTick(true)
    }, { deep: true })
  })

  // 加载会话列表
  const loadSessions = async () => {
    loading.value = true
    try {
      await chatStore.fetchSessions()
    } catch (error) {
      message.error('加载会话失败')
    } finally {
      loading.value = false
    }
  }

  // 创建新会话
  const createNewSession = async () => {
    try {
      await chatStore.createSession()
      
      // 获取最新创建的会话（新会话通过unshift添加到数组开头）
      const newSession = chatStore.sessions[0]
      
      // 自动打开新会话窗口并切换到该会话
      await toggleSession(newSession.id)
      
      message.success('新会话已创建')
    } catch (error) {
      message.error('创建会话失败')
    }
  }

  // 激活会话窗口
  const activateSession = async (sessionId) => {
    chatStore.activateSession(sessionId)
    activeSessions.value.add(sessionId)
    
    // 激活会话时自动最大化窗口
    maximizedSession.value = sessionId
  }

  // 停用会话窗口
  const deactivateSession = (sessionId) => {
    chatStore.deactivateSession(sessionId)
    activeSessions.value.delete(sessionId)
    
    // 如果停用的是最大化窗口，则清除最大化状态
    if (maximizedSession.value === sessionId) {
      maximizedSession.value = null
    }
  }

  // 切换会话窗口（打开/关闭）
  const toggleSession = async (sessionId) => {
    if (activeSessions.value.has(sessionId)) {
      // 如果会话已打开，则关闭
      deactivateSession(sessionId)
    } else {
      // 如果会话未打开，则打开
      
      // 首先关闭所有其他会话，确保只有一个会话处于活跃状态
      const sessionsToClose = Array.from(activeSessions.value)
      sessionsToClose.forEach(id => deactivateSession(id))
      
      // 使用nextTick确保DOM更新顺序正确，避免闪烁
      await nextTick()
      
      // 直接切换到目标会话，selectSession内部会处理激活和消息加载
      await chatStore.selectSession(sessionId)
      
      // 激活目标会话（确保窗口显示）- 注意：selectSession内部已经调用了activateSession
      // 这里只需要添加到activeSessions集合中
      activeSessions.value.add(sessionId)
      
      // 切换会话时自动最大化窗口
      maximizedSession.value = sessionId
      
      // 滚动到底部
      nextTick(() => {
        scrollToBottomNextTick()
      })
    }
  }

  // 关闭会话窗口
  const closeSession = (sessionId) => {
    deactivateSession(sessionId)
  }

  // 切换最大化窗口
  const toggleMaximize = (sessionId) => {
    if (maximizedSession.value === sessionId) {
      maximizedSession.value = null
    } else {
      maximizedSession.value = sessionId
    }
  }

  // 获取会话标题
  const getSessionTitle = (sessionId) => {
    const session = chatStore.sessions.find(s => s.id === sessionId)
    return session?.title || '未知会话'
  }

  // 获取会话消息
  const getSessionMessages = (sessionId) => {
    return chatStore.getSessionMessages(sessionId)
  }

  // 获取会话消息数量
  const getSessionMessageCount = (sessionId) => {
    return getSessionMessages(sessionId).length
  }

  // 获取会话文件列表
  const getSessionFiles = (sessionId) => {
    return chatStore.getSessionFiles(sessionId)
  }

  // 获取会话输入内容
  const getSessionInput = (sessionId) => {
    return chatStore.getSessionInput(sessionId)
  }

  // 设置会话输入内容
  const setSessionInput = (sessionId, value) => {
    const targetState = chatStore.getOrCreateSessionState(sessionId)
    if (targetState) {
      targetState.inputMessage = value
    }
  }

  // 判断会话是否正在加载
  const isSessionLoading = (sessionId) => {
    return chatStore.isSessionLoading(sessionId)
  }

  // 获取会话搜索开关状态
  const getSessionEnableSearch = (sessionId) => {
    return chatStore.getSessionEnableSearch(sessionId)
  }

  // 切换搜索开关状态
  const toggleSearch = (sessionId) => {
    const currentState = chatStore.getSessionEnableSearch(sessionId)
    chatStore.setSessionEnableSearch(sessionId, !currentState)
    
    // 显示状态提示
    const newState = !currentState
    message.success(newState ? '已开启联网搜索' : '已关闭联网搜索')
  }

  // 打开图片预览
  const openImagePreview = (imageUrl) => {
    previewImageUrl.value = imageUrl
    imagePreviewVisible.value = true
  }

  // 关闭图片预览
  const closeImagePreview = () => {
    imagePreviewVisible.value = false
    previewImageUrl.value = ''
  }

  // 判断会话是否活跃（正在执行任务）
  const isSessionActive = (sessionId) => {
    return chatStore.isSessionActive(sessionId)
  }

  // 获取AI的当前状态
  const getAiStatus = (sessionId) => {
    // 如果会话正在加载，检查AI是否已开始响应
    if (isSessionLoading(sessionId)) {
      const state = chatStore.getSessionState(sessionId)
      if (state && state.hasAiResponded) {
        return 'AI输出中'
      } else {
        return 'AI思考中'
      }
    }
    return ''
  }

  // 计算属性：分离置顶会话和普通会话
  const pinnedSessions = computed(() => {
    return chatStore.sessions.filter(session => session.pinned)
  })

  const normalSessions = computed(() => {
    return chatStore.sessions.filter(session => !session.pinned)
  })

  // 文件上传处理
  const beforeUpload = async (file, sessionId) => {
    // 获取文件扩展名
    const fileExtension = file.name.split('.').pop()?.toLowerCase() || ''
    
    // 动态获取后端配置
    let uploadConfig
    try {
      uploadConfig = await chatApi.getUploadConfig()
    } catch (error) {
      console.error('获取上传配置失败，使用默认配置:', error)
      // 使用默认配置作为后备
      uploadConfig = {
        max_file_size: 5242880, // 5MB
        allowed_extensions: ['txt', 'pdf', 'doc', 'docx', 'jpg', 'jpeg', 'png', 'gif']
      }
    }
    
    // 检查文件类型
    if (!uploadConfig.allowed_extensions.includes(fileExtension)) {
      message.error(`不支持的文件类型，支持的类型：${uploadConfig.allowed_extensions.join(', ')}`)
      return false
    }
    
    const isImage = file.type.startsWith('image/') || ['jpg', 'jpeg', 'png', 'gif'].includes(fileExtension)
    const isFile = !isImage
    
    // 检查文件大小
    if (file.size > uploadConfig.max_file_size) {
      const maxSizeMB = Math.round(uploadConfig.max_file_size / 1024 / 1024)
      message.error(`文件大小不能超过${maxSizeMB}MB`)
      return false
    }
    
    // 检查是否已经存在文件（图片或文档），如果存在则不允许上传新文件
    const existingFiles = getSessionFiles(sessionId)
    if (existingFiles.length > 0) {
      message.error('每个会话只能上传一个文件（图片或文档），请先移除已上传的文件')
      return false
    }
    
    try {
      // 上传文件到后端获取文件路径
      const authStore = useAuthStore()
      const apiBaseUrl = import.meta.env.VITE_API_BASE_URL || 'http://localhost:8000'
      
      const formData = new FormData()
      formData.append('file', file)
      
      const response = await fetch(`${apiBaseUrl}/chat/upload-file`, {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${authStore.token}`
        },
        body: formData
      })
      
      if (!response.ok) {
        throw new Error(`文件上传失败: ${response.status}`)
      }
      
      const result = await response.json()
      
      // 创建文件预览对象，包含上传后的文件路径和文件ID
      const fileObj = {
        id: generateGuid(),
        file: file,
        name: file.name,
        type: isImage ? 'image' : 'file',
        previewUrl: isImage ? URL.createObjectURL(file) : null,
        filePath: result.file_path, // 后端返回的文件路径
        fileId: result.file_id // 后端返回的文件ID
      }
      
      // 添加到会话文件列表
      chatStore.addFileToSession(sessionId, fileObj)
      
      // 上传文件后自动禁用联网搜索功能
      chatStore.setSessionEnableSearch(sessionId, false)
      
      message.success('文件上传成功，联网搜索已自动禁用')
      return false // 阻止自动上传
      
    } catch (error) {
      console.error('文件上传失败:', error)
      message.error('文件上传失败，请稍后重试')
      return false
    }
  }

  // 移除文件
  const removeFile = (fileId, sessionId) => {
    chatStore.removeFileFromSession(sessionId, fileId)
    
    // 移除文件后检查是否还有文件，如果没有则重新启用联网搜索
    const remainingFiles = getSessionFiles(sessionId)
    if (remainingFiles.length === 0) {
      chatStore.setSessionEnableSearch(sessionId, true)
      message.success('文件已移除，联网搜索已重新启用')
    }
  }

  // 触发文件上传（通过下拉菜单选择）
  const triggerFileUpload = async (type, sessionId) => {
    // 动态获取后端配置
    let uploadConfig
    try {
      uploadConfig = await chatApi.getUploadConfig()
    } catch (error) {
      console.error('获取上传配置失败，使用默认配置:', error)
      // 使用默认配置作为后备
      uploadConfig = {
        allowed_extensions: ['txt', 'pdf', 'doc', 'docx', 'jpg', 'jpeg', 'png', 'gif']
      }
    }
    
    // 创建隐藏的文件输入元素
    const input = document.createElement('input')
    input.type = 'file'
    input.style.display = 'none'
    
    // 根据后端配置动态设置接受的文件类型
    if (type === 'image') {
      const imageExtensions = uploadConfig.allowed_extensions.filter(ext => 
        ['jpg', 'jpeg', 'png', 'gif'].includes(ext)
      )
      const acceptTypes = imageExtensions.map(ext => {
        if (['jpg', 'jpeg', 'png', 'gif'].includes(ext)) {
          return `image/${ext === 'jpg' ? 'jpeg' : ext},.${ext}`
        }
        return `.${ext}`
      }).join(',')
      input.accept = acceptTypes
    } else {
      const fileExtensions = uploadConfig.allowed_extensions.filter(ext => 
        !['jpg', 'jpeg', 'png', 'gif'].includes(ext)
      )
      const acceptTypes = fileExtensions.map(ext => `.${ext}`).join(',')
      input.accept = acceptTypes
    }
    
    // 处理文件选择
    input.onchange = (e) => {
      const file = e.target.files[0]
      if (file) {
        // 调用现有的beforeUpload函数处理文件
        beforeUpload(file, sessionId)
      }
      
      // 清理DOM
      document.body.removeChild(input)
    }
    
    // 添加到DOM并触发点击
    document.body.appendChild(input)
    input.click()
  }

  // 处理回车键
  const handleEnterKey = (e, sessionId) => {
    if (e.ctrlKey || e.metaKey) {
      // Ctrl+Enter 或 Cmd+Enter：插入换行符
      e.preventDefault()
      
      const textarea = e.target
      const start = textarea.selectionStart
      const end = textarea.selectionEnd
      const value = textarea.value
      
      // 在光标位置插入换行符
      textarea.value = value.substring(0, start) + '\n' + value.substring(end)
      
      // 设置光标位置到换行符后
      textarea.selectionStart = textarea.selectionEnd = start + 1
      
      // 触发input事件以更新Vue数据
      const inputEvent = new Event('input', { bubbles: true })
      textarea.dispatchEvent(inputEvent)
    } else {
      // 直接回车：发送消息
      e.preventDefault()
      handleSendMessage(sessionId)
    }
  }

  // 发送消息
  const handleSendMessage = async (sessionId) => {
    const content = getSessionInput(sessionId)?.trim() || ''
    const files = getSessionFiles(sessionId)
    
    if (!content && files.length === 0) {
      message.error('请输入消息内容或上传文件')
      return
    }
    
    try {
        // 构建发送参数
        const params = {
          content: content,
          messageType: files.length > 0 ? (files[0].type === 'image' ? 'image' : 'file') : 'text',
          file: files.length > 0 ? files[0] : null,
          filePath: files.length > 0 ? files[0].filePath : null // 使用上传后的文件路径
        }
        
        // 使用会话特定的流式消息发送方法
        await chatStore.sendMessageStreamToSession(sessionId, params)
        
        // 消息发送成功后清空输入框和文件列表
        chatStore.clearSessionInput(sessionId)
        chatStore.clearSessionFiles(sessionId)
        
    } catch (error) {
      console.error('消息发送失败：', error)
      
      // 检查是否为认证错误或网络错误，避免重复显示提示
      const isAuthError = error?.response?.status === 401 || error?.message?.includes('401')
      const isNetworkError = !error?.response && error?.message?.includes('Network')
      
      // 只有在非认证/网络错误时才显示通用错误提示
      if (!isAuthError && !isNetworkError) {
        message.error('消息发送失败，请稍后重试')
      }
    }
  }

  // 置顶/取消置顶会话
  const togglePinSession = async (sessionId, isPinned) => {
    try {
      await chatStore.pinSession(sessionId, isPinned)
      message.success(isPinned ? '会话已取消置顶' : '会话已置顶')
    } catch (error) {
      message.error(isPinned ? '取消置顶失败' : '置顶会话失败')
    }
  }

  // 删除会话
  const deleteSession = async (sessionId) => {
    try {
      // 获取会话标题用于确认对话框
      const session = chatStore.sessions.find(s => s.id === sessionId)
      const sessionTitle = session?.title || '新会话'
      
      // 显示确认对话框
      Modal.confirm({
        title: '确认删除',
        content: `确定要删除会话 "${sessionTitle}" 吗？此操作不可撤销。`,
        okText: '确认删除',
        cancelText: '取消',
        okType: 'danger',
        centered: true,
        maskClosable: true,
        onOk: async () => {
          try {
            // 如果会话窗口是打开的，先关闭窗口
            if (activeSessions.value.has(sessionId)) {
              deactivateSession(sessionId)
            }
            
            await chatStore.deleteSession(sessionId)
            message.success('会话删除成功')
          } catch (error) {
            message.error('删除会话失败')
            throw error // 重新抛出错误以保持对话框状态
          }
        }
      })
    } catch (error) {
      console.error('删除会话失败：', error)
    }
  }

  // 获取图片URL
  const getImageUrl = (filePath) => {
    if (!filePath) return ''
    
    // 如果filePath已经是完整URL，直接返回
    if (filePath.startsWith('http')) {
      return filePath
    }
    
    // 标准化文件路径：将反斜杠转换为正斜杠
    const normalizedPath = filePath.replace(/\\/g, '/')
    
    // 如果路径已经以uploads开头，直接使用
    if (normalizedPath.startsWith('uploads/')) {
      return `${import.meta.env.VITE_API_BASE_URL}/${normalizedPath}`
    }
    
    // 否则直接拼接uploads路径
    return `${import.meta.env.VITE_API_BASE_URL}/uploads/${normalizedPath}`
  }

  // 下载文件
  const downloadFile = async (filePath, fileId = null) => {
    try {
      // 从文件路径中提取文件名
      const separator = filePath.includes('\\') ? '\\' : '/'
      const fileName = filePath.split(separator).pop()
      
      const authStore = useAuthStore()
      const apiBaseUrl = import.meta.env.VITE_API_BASE_URL || 'http://localhost:8000'
      
      // 直接路径下载
      const directDownloadUrl = `${apiBaseUrl}/uploads/${filePath.replace(/\\\\/g, '/').replace(/^uploads\//, '')}`
      
      // 使用XMLHttpRequest进行下载
      const xhr = new XMLHttpRequest()
      xhr.open('GET', directDownloadUrl, true)
      xhr.setRequestHeader('Authorization', `Bearer ${authStore.token}`)
      xhr.responseType = 'blob'
      
      xhr.onload = function() {
        if (this.status === 200) {
          // 下载成功
          const blob = this.response
          const url = window.URL.createObjectURL(blob)
          const a = document.createElement('a')
          a.style.display = 'none'
          a.href = url
          a.download = fileName.split('_').slice(1).join('_') // 移除UUID部分
          document.body.appendChild(a)
          a.click()
          window.URL.revokeObjectURL(url)
          document.body.removeChild(a)
        } else {
          // 下载失败
          console.error('文件下载失败: HTTP状态码', this.status)
          message.error('文件下载失败，请稍后重试')
        }
      }
      
      xhr.onerror = function() {
        // 下载失败
        console.error('文件下载失败: 网络错误')
        message.error('文件下载失败，请稍后重试')
      }
      
      xhr.send()
      
    } catch (error) {
      console.error('文件下载失败:', error)
      message.error('文件下载失败，请稍后重试')
    }
  }

  // 从文件路径中提取文件名（移除UUID前缀）
  const getFileName = (filePath) => {
    if (!filePath) return ''
    
    // 从路径中提取文件名
    const separator = filePath.includes('\\') ? '\\' : '/'
    const fileName = filePath.split(separator).pop()
    
    // 移除UUID前缀（格式：{uuid}_{original_filename}）
    if (fileName.includes('_')) {
      const parts = fileName.split('_')
      if (parts.length > 1) {
        // 移除UUID部分，保留原始文件名
        return parts.slice(1).join('_')
      }
    }
    
    return fileName
  }

  // 格式化时间
  const formatTime = (timestamp) => {
    if (!timestamp) return ''
    
    const date = new Date(timestamp)
    const now = new Date()
    const diff = now - date
    
    if (diff < 60 * 1000) {
      return '刚刚'
    } else if (diff < 60 * 60 * 1000) {
      return `${Math.floor(diff / (60 * 1000))}分钟前`
    } else if (diff < 24 * 60 * 60 * 1000) {
      return `${Math.floor(diff / (60 * 60 * 1000))}小时前`
    } else {
      return date.toLocaleDateString()
    }
  }

  // 滚动到消息底部
  const scrollToBottomNextTick = (force = false) => {
    nextTick(() => {
      if (messagesContainer.value && (force || !isScrolledUp())) {
        messagesContainer.value.scrollTop = messagesContainer.value.scrollHeight
      }
    })
  }

  // 检查是否向上滚动
  const isScrolledUp = () => {
    if (!messagesContainer.value) return false
    
    const container = messagesContainer.value
    const scrollBottom = container.scrollHeight - container.scrollTop - container.clientHeight
    return scrollBottom > 100 // 如果距离底部超过100px，则认为用户向上滚动了
  }

  // 渲染消息内容
  const renderMessageContent = (content) => {
    if (!content) return ''
    
    // 处理HTML表格：去掉代码块标记并添加边框样式
    let processedContent = content
    
    // 去掉HTML代码块标记：```html 和结尾的```
    processedContent = processedContent.replace(/```html\n?/g, '')
    processedContent = processedContent.replace(/```\n?/g, '')
    
    // 去掉HTML标签之间的多余空格（保留文本内容中的空格）
    processedContent = processedContent.replace(/>\s+</g, '><')
    
    // 去掉HTML标签前后的多余空格
    processedContent = processedContent.replace(/\s+</g, '<')
    processedContent = processedContent.replace(/>\s+/g, '>')
    
    // 为表格添加边框样式
    processedContent = processedContent.replace(/<table>/g, '<table style="border: 1px solid #ddd; border-collapse: collapse; width: 100%; margin: 10px 0;">')
    processedContent = processedContent.replace(/<th>/g, '<th style="border: 1px solid #ddd; padding: 8px; background-color: #f5f5f5; text-align: left;">')
    processedContent = processedContent.replace(/<td>/g, '<td style="border: 1px solid #ddd; padding: 8px;">')
    
    // 将换行符转换为HTML换行
    processedContent = processedContent.replace(/\n/g, '<br>')
    
    return processedContent
  }

  // 退出登录
  const handleLogout = async () => {
    try {
      await authStore.logout()
      message.success('退出成功')
    } catch (error) {
      message.error('退出失败')
    }
  }

  return {
    authStore,
    chatStore,
    loading,
    messagesContainer,
    activeSessions,
    maximizedSession,
    imagePreviewVisible,
    previewImageUrl,
    pinnedSessions,
    normalSessions,
    loadSessions,
    createNewSession,
    activateSession,
    deactivateSession,
    toggleSession,
    closeSession,
    toggleMaximize,
    getSessionTitle,
    getSessionMessages,
    getSessionMessageCount,
    getSessionFiles,
    getSessionInput,
    setSessionInput,
    isSessionLoading,
    getSessionEnableSearch,
    toggleSearch,
    openImagePreview,
    closeImagePreview,
    isSessionActive,
    getAiStatus,
    beforeUpload,
    removeFile,
    triggerFileUpload,
    handleEnterKey,
    handleSendMessage,
    togglePinSession,
    deleteSession,
    getImageUrl,
    downloadFile,
    getFileName,
    formatTime,
    scrollToBottomNextTick,
    isScrolledUp,
    renderMessageContent,
    handleLogout
  }
}